wayland: Silence warnings on clipboard data sending cancellation

During copy/paste, it may be common that we receive several property changes
around the selection atom, this results in warnings when cancelling the previous
write attempt. We already honor the last request properly, so we should just
cancel silently.

wayland: Ensure we re-request the target if the fd changes

If we receive wl_data_source.target before .send, the target would already
be cached, but we'd take no action on the new fd.

wayland: Don't accept the "TARGETS" target on the wl_data_offer

This is handled separately through the data already cached from the
wl_data_offer.offer handler, we can avoid this request entirely then.

Updated Serbian translation

Adwaita: Fix context menu shadows not showing up

inspector: Make it easier to cut'n'paste advice message

The message says "Enable statistics with GOBJECT_DEBUG=instance-count"
but the message itself isn't selectable, making it hard to cut'n'paste.

https://bugzilla.gnome.org/show_bug.cgi?id=746391

csspathnode: Handle context going away

Sometimes path nodes can survive longer than the style context that
created them. Don't crash in those cases.

Fixes startup of mutter.

Testcase included.

https://bugzilla.gnome.org/show_bug.cgi?id=746407

inspector: Add a new page that lists the CSS node tree

cssnode: Add properties

csswidgetnode: Use style_changed signal instead of update_style vfunc

cssnode: Add a style-changed signal

The signal gets emitted whenever the style needs to be changed.

cssnode: Add node-added and node-removed signal

This allows monitoring the CSS tree. For now, moving a child to a
different position relative to its siblings while keeping the same
parent will cause a child-added + child-removed emission.

cssnode: Track invalid children

We need to properly track if a node needs to propagate invalidation
state information to its children. We didn't do this properly before and
that could lead to us forgetting to invalidate nodes in corner cases.

csswidgetnode: Avoid creating a stylecontext

If the widget doesn't have a style context, don't create one. Instead,
call functions on the widget directly.

cssnode: Change the way we invalidate timestamps

Do not propagate the TIMESTAMP change through the node tree, as that
causes lots of uneeded markings of nodes as invalid.

Instead, walk the node tree and find the nodes that have a non-static
style and only invalidate timestamps on those.

cssstyle: Add gtk_css_style_is_static()

Gets rid of the need to do

  if (ANIMATED_STYLE() &&
      animated_style_is_static(ANIMATED_STYLE(style))

cssnode: Special-case TIMESTAMP invalidations

Only invalidate timestamps if the node is marked as invalid. We overload
the meaning of "invalid" as "tracks timestamps".

While I don't like the way this is written, it is an important
optimization because 95+% of nodes don't animate so timestamps don't
matter to them. But timestamps are invalidated 60x per second.

cssnode: Redo style changed tracking

We don't return a NULL style to mean "no changes" anymore, instead
we check new_style == old_style to mean that.

Make sure the code reflects this, otherwise we'll send
GTK_CSS_CHANGE_PARENT_STYLE invalidations everywhere and screw up
performance.

stylecontext: Call get_style(), not create_style()

We want to ensure that the style is created properly.

This also allows making the create_Style() function private.

cssnode: Merge the 2 places that compute styles

Now that the widget node recomputes styles on update_style() we can just
call it during validate(). That way, we don't need the widget node to
manually compute its style.

cssnode: Always return correct style values

If CSS values are queried from a widget, recompute them if necessary. Do
not emit style-updated until the validation phase however.

This way, we don't run into performance traps when style-update causes
invalidations that cause new style-updated to be emitted.

cssstyle: Add optimization

There is no difference between a style and itself.

stylecontext: Refactor gtk_style_context_invalidate()

There's no need anymore to recreate styles, nodes do that automagically
now.

This allows making gtk_css_node_set_style() private.

cssnode: Create animated styles by default

... and hardcode transient and path nodes to never create animated
styles.

cssnode: Add optimization

Don't even try to propagate changes when we know there are none.

cssnode: Change the way we start animations

We now have a flag for "invalidate animations", use that to restart
animations and decide if we want to start transitions.

cssnode: Return NULL as frame clock when animations are disabled

This is a crude hack, but it works.

FIXME: Hook it up to the GtkSettings so that we properly update when the
setting changes.

cssstyle: Handle 0 timestamp to mean "don't animate"

cssnode: Move style context function to only user

cssnode: Remove timestamp from gtk_css_node_validate()

GtkCssNode knows its own timestamp.

cssnode: Add API to query the timestamp

... and pass it to the API that computes new styles.

A special timestamp of 0 means "please don't animate" and is used when
no frame clock is available for a node.

cssnode: Make parent style change part of GtkCssNode

cssnode: Propagate pending changes after recomputing new style

This way we can propagate if the new style actually changed anything.

cssnode: Add gtk_css_node_invalidate_style_provider()

This function not just invalidates the current node, but also all
children.

cssnode: Change get_style_provider() vfunc

Instead of always returning a provider, allow the vfunc to return NULL
to mane "use same provider as parent". This allows a bunch of
optimizations.

cssnode: Implement a way to properly track invalidations

See the comment in gtkcssnodeprivate.h for how this works.

cssnode: Change vfunc

This is mainly an attempt to merge the update_style() and validte()
vfuncs. Code is not there yet, but that's the idea.

Also, gtk_css_node_set_style() should not be public. And this gets
closer to that goal, too.

cssnode: Only pass a boolean for parent changes

Nobody cares what changed in the parent, so don't track it.

cssvalue: Remove GtkCssDependencies

They are not used anymore.

cssstyle: Remove unused optimization

After measuring it, I realized the optimization never triggers for
Adwaita and rarely ever triggers for simple themes. So it is not
useful to keep it around.

csswidgetnode: Always return a valid style

csspathnode: Call gtk_style_context_validate()

Don't call gtk_style_context_invalidate(), that function does too much
work.

testsuite: Add another random stylecontext test

cssnode: Use the frame clock's time

... nstead of the monotonic time when validating a cssnode.

cssnode: Treat transient nodes as invisible nodes

Making transient nodes invisible allows us to remove special cases
without any bad side effects and they continue working just like they
did before.

reftests: Add a reftest for box sibling ordering

cssnode: Add visibility concept

This allows hiding nodes of invisible widgets.
And that in turn makes sure :nth-child() works as expected.

box: Use CSS nodes instead of widget paths

This is a very simple patch that causes a bunch of overhead. But it
works.

widget: Add gtk_widget_get_css_node()

and replace gtk_style_context_get_root() with it.

cssnode: Refactor node tree modification code

This allows adding more API for it.

It also includes code that tracks modifications and invalidates siblings
and their positions whenever nodes get added or removed.

cssnode: Add hackery to allow bypassing widget paths

If we know the parent's get_path_for_child() implementation is safe to
be used with GtkCssNode because it doesn't do anything special, we do
that. Unfortunately that requires whitelisting vfuncs because the vfunc
is public API so anyone can override it.

cssnode: Remove now unused arg from vfunc

cssnode: Add a matcher for nodes

... and use that matcher by default - ie for transient nodes.

cssnode: Make widget node not copy the path

Instead, use gtk_widget_get_path() which makes GtkWidget cache the path.
This is a temporary solution until we can get rid of widget paths.

This increases memory usage quite noticably.

cssnode: Make widget node use new matcher

cssnode: Make path node create matcher without copying

... the WidgetPath. This uses the functionality introduced in the
previous commits.

cssmatcher: Allow widget path matcher to take a node declaration

The node declaration has the same functionality as
gtk_css_node_declaration_add_to_widget_path(). So instead of using that
function on a path, you can use the original path and the declaration in
a matcher.

cssnode: Split out a function

So far the vfunc is kinda quirky (the path argument is an out argument
for something you have to free when you're done with the matcher), but
  I'm about to change that.

widget: Create widget path classes from proper style

We don't want to add the current classes to the widget path - which
might potentially be different after a gtk_style_context_save() - but
the root node's ones. So what better thing to do than actually using the
root node?

widget: Use correct type for widgetpath creation

This is relevant when the widget path is created while the widget is
still constructing. G_OBJECT_TYPE(widget) might not point to the final
type yet.

widget: Create the CssNode

... and pass it to the style context instead of having the style context
create it for us.

cssnode: Refactor invalidation propagation

We want to be sure to gtk_css_node_invalidate() all potential changes.

stylecontext: Don't queue animate tick callbacks anymore

Instead, just mark nodes permanently as invalid.

cssnode: Handle invalidate queueing differently

Instead of directly requesting the layout phase, register a tick
callback. This is what the docs suggest for animations and it's what we
need for the next commit.

cssnode: Change way invalidation is handled

Have a queue_validate() vfunc and a dequeue_validate() vfunc that are
called only on root nodes so they can queue a validation on their frame
clocks.

cssnode: Refactor gtk_css_widget_node_validate()

Makes it clearer what actually happens in that function.

cssnode: Only recreate styles when needed

cssnode: Automatically recreate style on get_style() call

When the style is invalid, redo it.

Make this a vfunc, so the widget nodes can opt out.

cssnode: Track pending changes here

... instead of GtkCssWidgetNode.

stylecontext: Move gtk_style_context_validate() to GtkCssWidgetNode

stylecontext: Move style creation functions to CssNode code

stylecontext: Redo handling of differing state

Instead of passing an "override_state" flag, create a new CssNode just
for this simple lookup.

stylecontext: Get rid of stylecontext argument

... to a bunch of functions.

This requires a tiny change to the heuristics for the style cache - we
now cache styles when they have the same style provider as their parent
instead of when they have the default provider - but that change doesn't
have any effect in practice.

cssnode: Add gtk_style_context_get_style_provider()

... and use it when looking up properties.

stylecontext: Remove children list

It's not needed.

stylecontext: Move validation into GtkCssNode

stylecontext: Export gtk_style_context_get_root()

.. in the private header. This avoids tiny wrapper functions.

cssnode: Track invalid flag

Remove it from GtkStyleContext.

cssnode: Implement refcounting

The parent refs the child, so gtk_css_node_set_parent() adds/removes a
reference.

We should probably refactor this so that we name the function
parent.add(node) instead of node.set_parent(parent) - makes the
refcounting more clear.

stylecontext: Handle parent in CssNode code

Make CssNode a real tree with a DOM-like API.

stylecontext: Move relevant_changes tracking to GtkCssWidgetNode

cssnode: Handle invalidation

Handle invalidation of node inside the CssNode code, don't do it in the
stylecontext.

stylecontext: Get rid of create_query_path()

Move that functionality into GtkCssNode.

stylecontext: Change arguments for build_properties

Instead of passing the style declaration, take the node's style
declaration. Add arguments to allow overriding the state for the one
case where this didn't work.

stylecontext: Compute rootness of CssNode

.. instead of passing it as an argument.

stylecontext: Pass cssnode to build_properties

stylecontext: Simplify a function

stylecontext: Remove values cache

The code is confusing the stylecontext=>node transition, so I'll remove
it.

WIth the recent introduction of the parent style cachen, I'm not sure
it's worth it at all. Some crude benchmarking suggests a slight speedup
when removing the cache.

So no guarantees about adding it back later.

cssnode: Split into 3 objects

- GtkCssWidgetNode
  for style contexts owned by a widget
- GtkCssPathNode
  for style contexts using a GtkWidgetPath
- GtkCssTransientNode
  for nodes created with gtk_style_context_save()/restore()

cssnode: Turn into a GObject

This will allow us to use subclasses.

stylecontext: Turn CssNode accesses into getters/setters

That way we can hide the struct in the source file.

stylecontext: Split out GtkCssNode into own file

The functionality of it is supposed to grow, so better put it in a
custom file early.

This is just a naive split so far, the next patches will split things
further.

render: Make image effect not depend on state

Instead rely on -gtk-image-effect only. Adwaita should already work this
way.

Relying on state was a leftover feature from the GTK 2 days.

notebook: Protect against invalid allocations

A widget can be mapped but not have a size allocated yet. In that case
avoid computing a broken rectangle.

https://bugzilla.gnome.org/show_bug.cgi?id=746301

wayland: Fix thinko in wl_data_source.cancelled handler

The wl_data_source may be the clipboard's. Looking up the drag context in
order to get the display isn't going to fare well there. So, just use the
default display, and only look up the drag context when we know we need it.

https://bugzilla.gnome.org/show_bug.cgi?id=746386

textview: add support for underline and strikethrough colors

This commit adds the GtkTextTag:underline-rgba and :strikethrough-rgba
properties and the necessary plumbing to apply these colors in GtkTextLayout.
With this change, you can alter the color of underlines including those
of type PANGO_UNDERLINE_ERROR.

You might want to alter the underline color to differentiate between
spelling and grammer mistakes. In code editors, it is convenient to
differentiate between errors and warnings.

Note that the GtkTextAppearance struct is public ABI and has no spare
room for new fields, so we are resorting to some tricky packing to store
the colors in the unused pixel field of the fg_color and bg_color structs.
This packing is accomplished by the macros in gtktextattributesprivate.h.

Signed-off-by: Christian Hergert <christian@hergert.me>
https://bugzilla.gnome.org/show_bug.cgi?id=402168

GtkRange: Fix scroll wheel direction for horizontal ranges

The expected behavior here is that scrolling up goes towards
larger values, ie to the right. This matches e.g. volume
sliders in gnome-shell.

https://bugzilla.gnome.org/show_bug.cgi?id=737175

scrolled window: Use shift to modify scroll direction

It has been a long-standing request to interpret scroll events
with Shift held down as horizontal instead of vertical, and
some applications are already doing this on their own.

https://bugzilla.gnome.org/show_bug.cgi?id=132197

HighContrast: Fix calendar selection

The selected day was not differentiated from other
days at all. Render it white on black instead.

https://bugzilla.gnome.org/show_bug.cgi?id=746369

HighContrast: Fix color chooser marks

The checkmark for the selected color was always black,
making it more or less invisible on dark colors.

https://bugzilla.gnome.org/show_bug.cgi?id=746368